// sgu321
// 题意：
// 给定一个n(<=200000)个节点的树，每条边初始是protected或者almost protected，
// 问最少将哪些边改成protected使得每个节点到1号点的路上至少有一半的protected边。
//
// 题解：
// 贪心，很明显越靠近根越好，接下来就是怎么实现了。一开始我写了个O(n logn)的
// 算法，dfs到某个点二分到需要回填的到根的节点，然后回溯的时候打了标记点
// 到根节点的边都需要被改成protected。
//
// 其实也可以做到O(n)，只需要先处理出每个节点到根还需要protected边数，
// 然后再维护出每个结点子树中需要protected边最大的数目，如果u到其子树还需要
// 这条边并且是almost protected的边，那么就改成protected。
//
// #pragma comment(linker, "/STACK:50000000")
// run: $exec < input
// opt: 0
// flag: -g
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

struct edge
{
	int u, v, id;
	bool pro;
};

std::vector<std::vector<edge> > tree;
std::vector<edge> edges;
int const maxn = 200007;
int vis[maxn];
int sum[maxn];
bool protect[maxn];
int n;

bool dfs(int u, int parent, int deep, int cp)
{
	if (cp * 2 < deep) {
		int l = 0, r = deep - 1, need = (deep + 1) / 2 - cp;
		while (l + 1 < r) {
			int mid = (l + r) / 2;
			if (sum[mid] < need) l = mid;
			else r = mid;
		}
		if (sum[l] >= need) r = l;
		protect[vis[r]] = true;
	}
	bool ret = false;
	for (int i = 0; i < (int)tree[u].size(); i++) {
		int v = tree[u][i].v, p = tree[u][i].pro;
		if (v == parent) continue;
		vis[deep] = tree[u][i].id;
		sum[deep] = !p;
		if (deep) sum[deep] += sum[deep - 1];
		if (dfs(v, u, deep + 1, cp + p)) protect[tree[u][i].id] = true;
		if (protect[tree[u][i].id]) ret = true;
	}
	return ret;
}

void print(int x)
{
	static bool first = true;
	if (first) { std::cout << x; first = false; }
	else std::cout << " " << x;
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin >> n;
	tree.resize(n + 1);
	std::string s;
	for (int i = 0, u, v; i < n - 1; i++) {
		std::cin >> u >> v;
		std::cin >> s;
		edge tmp; tmp.u = u; tmp.v = v; tmp.id = i;
		if (s[0] == 'a') {
			std::cin >> s;
			tmp.pro = false;
		} else tmp.pro = true;
		edges.push_back(tmp);
		tree[u].push_back(tmp);
		std::swap(tmp.u, tmp.v);
		tree[v].push_back(tmp);
	}
	dfs(1, -1, 0, 0);
	int ans = 0;
	for (int i = 0; i < n - 1; i++)
		if (protect[i] && !edges[i].pro) ans++;
	std::cout << ans << '\n';
	for (int i = 0; i < n - 1; i++)
		if (protect[i] && !edges[i].pro) print(i + 1);
}

